package com.warm.pump.module.skd.dao.gen;

import java.util.List;
import java.util.Map;
import java.util.Date;
import java.math.BigDecimal;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import com.warm.pump.frame.gen.bean.PageBean;
import com.warm.pump.frame.gen.util.TypeCast;
import com.warm.pump.frame.gen.exception.ServiceException;
import com.warm.pump.module.skd.bean.po.gen.ScheduleInstanceDtl;
import com.warm.pump.module.skd.mapper.gen.ScheduleInstanceDtlMapper;
import com.warm.pump.module.skd.bean.po.gen.ScheduleInstanceDtlExample;

@Repository
public class ScheduleInstanceDtlDao {
    // 日志对象
    private transient Log log = LogFactory.getLog(this.getClass());
    @Autowired
    private ScheduleInstanceDtlMapper scheduleInstanceDtlMapper;

    // 增加一个后台ScheduleInstanceDtl表

    public boolean insert(ScheduleInstanceDtl scheduleInstanceDtl) {
        try {
            scheduleInstanceDtlMapper.insert(scheduleInstanceDtl);
            log.debug("后台ScheduleInstanceDtl表增加成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleInstanceDtl表增加失败");
            throw new ServiceException("后台ScheduleInstanceDtl表增加失败", e);
        }
    }
    // 增加一个后台ScheduleInstanceDtl表Selective

    public boolean insertSelective(ScheduleInstanceDtl scheduleInstanceDtl) {
        try {
            scheduleInstanceDtlMapper.insertSelective(scheduleInstanceDtl);
            log.debug("后台ScheduleInstanceDtl表增加成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleInstanceDtl表增加失败");
            throw new ServiceException("后台ScheduleInstanceDtl表增加失败", e);
        }
    }

    // 删除一个后台ScheduleInstanceDtl表

    public boolean deleteByPrimaryKey(Long id) {
        try {
            scheduleInstanceDtlMapper.deleteByPrimaryKey(id);
            log.debug("后台ScheduleInstanceDtl表删除成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleInstanceDtl表删除失败");
            throw new ServiceException("后台ScheduleInstanceDtl表删除失败", e);
        }
    }
    // 删除一个后台ScheduleInstanceDtl表byMap

    public boolean deleteByMap(Map scheduleInstanceDtlMap) {
        try {
            scheduleInstanceDtlMapper.deleteByExample(createScheduleInstanceDtlExample(scheduleInstanceDtlMap, null, null));
            log.debug("后台ScheduleInstanceDtl根据Map删除成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleInstanceDtl根据GroupID删除失败");
            throw new ServiceException("后台ScheduleInstanceDtl根据object删除失败", e);
        }
    }
    // 修改一个后台ScheduleInstanceDtl表

    public boolean updateByPrimaryKey(ScheduleInstanceDtl scheduleInstanceDtl) {
        try {
            scheduleInstanceDtlMapper.updateByPrimaryKey(scheduleInstanceDtl);
            log.debug("后台ScheduleInstanceDtl表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleInstanceDtl表修改失败");
            throw new ServiceException("后台ScheduleInstanceDtl表修改失败", e);
        }
    }
    // 修改一个后台ScheduleInstanceDtl表Selective

    public boolean updateByPrimaryKeySelective(ScheduleInstanceDtl scheduleInstanceDtl) {
        try {
            scheduleInstanceDtlMapper.updateByPrimaryKeySelective(scheduleInstanceDtl);
            log.debug("后台ScheduleInstanceDtl表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台ScheduleInstanceDtl表修改失败");
            throw new ServiceException("后台ScheduleInstanceDtl表修改失败", e);
        }
    }
    // 修改一个后台ScheduleInstanceDtl表

    public boolean updateByMap(ScheduleInstanceDtl scheduleInstanceDtl, Map scheduleInstanceDtlMap) {
        try {
            scheduleInstanceDtlMapper.updateByExample(scheduleInstanceDtl, createScheduleInstanceDtlExample(scheduleInstanceDtlMap, null, null));
            log.debug("后台批量ScheduleInstanceDtl表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台批量ScheduleInstanceDtl表修改失败");
            throw new ServiceException("后台ScheduleInstanceDtl表批量修改失败", e);
        }
    }
    // 修改一个后台ScheduleInstanceDtl表Selective

    public boolean updateByMapSelective(ScheduleInstanceDtl scheduleInstanceDtl, Map scheduleInstanceDtlMap) {
        try {
            scheduleInstanceDtlMapper.updateByExampleSelective(scheduleInstanceDtl, createScheduleInstanceDtlExample(scheduleInstanceDtlMap, null, null));
            log.debug("后台批量ScheduleInstanceDtl表修改成功");
            return true;
        } catch (Exception e) {
            log.debug("后台批量ScheduleInstanceDtl表修改失败");
            throw new ServiceException("后台ScheduleInstanceDtl表批量修改失败", e);
        }
    }

    // 查询一个后台ScheduleInstanceDtl表

    public ScheduleInstanceDtl selectByPrimaryKey(Long id) {
        return scheduleInstanceDtlMapper.selectByPrimaryKey(id);
    }

    // 查询一个后台ScheduleInstanceDtl表-根据map

    public ScheduleInstanceDtl selectByMap(Map scheduleInstanceDtlMap) {
        List<ScheduleInstanceDtl> list = getListByMap(scheduleInstanceDtlMap);
        if (list == null || list.isEmpty()) {
            return null;
        } else {
            return list.get(0);
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // 查询所有后台ScheduleInstanceDtl表

    public List<ScheduleInstanceDtl> getListByMap(Map scheduleInstanceDtlMap) {

        return scheduleInstanceDtlMapper.selectByExample(createScheduleInstanceDtlExample(scheduleInstanceDtlMap, null, null));
    }

    //统计后台ScheduleInstanceDtl表数量

    public int countTotalByMap(Map scheduleInstanceDtlMap) {

        return scheduleInstanceDtlMapper.countByExample(createScheduleInstanceDtlExample(scheduleInstanceDtlMap, null, null));
    }


    public List<ScheduleInstanceDtl> getListByMapPage(Map scheduleInstanceDtlMap, int limitStart,
                                                      int limitOffset) {

        return scheduleInstanceDtlMapper.selectByExample(createScheduleInstanceDtlExample(scheduleInstanceDtlMap, limitStart, limitOffset));
    }


    public PageBean getPageBeanByMap(Map scheduleInstanceDtlMap, int pageNo, int pageSize) {
        Integer count = countTotalByMap(scheduleInstanceDtlMap);
        PageBean pageBean = new PageBean();
        pageBean.setCount(count);
        pageBean.setPageNo(pageNo);
        pageBean.setPageSize(pageSize);
        int limitStart = pageBean.getStartNo();
        int limitOffset = pageSize;
        pageBean.setData(scheduleInstanceDtlMapper.selectByExample(createScheduleInstanceDtlExample(scheduleInstanceDtlMap, limitStart, limitOffset)));
        return pageBean;
    }

    private ScheduleInstanceDtlExample createScheduleInstanceDtlExample(Map scheduleInstanceDtlMap, Integer limitStart, Integer limitOffset) {
        ScheduleInstanceDtlExample scheduleInstanceDtlEx = new ScheduleInstanceDtlExample();
        ScheduleInstanceDtlExample.Criteria c = scheduleInstanceDtlEx.createCriteria();
        Long id_null = TypeCast.getLong(scheduleInstanceDtlMap.get("id_null"));
        Long id_notNull = TypeCast.getLong(scheduleInstanceDtlMap.get("id_notNull"));
        Long id = TypeCast.getLong(scheduleInstanceDtlMap.get("id"));
        Long id_not = TypeCast.getLong(scheduleInstanceDtlMap.get("id_not"));
        Long id_greater = TypeCast.getLong(scheduleInstanceDtlMap.get("id_greater"));
        Long id_greaterEqual = TypeCast.getLong(scheduleInstanceDtlMap.get("id_greaterEqual"));
        Long id_less = TypeCast.getLong(scheduleInstanceDtlMap.get("id_less"));
        Long id_lessEqual = TypeCast.getLong(scheduleInstanceDtlMap.get("id_lessEqual"));
        List<Long> id_in = TypeCast.getLongList(scheduleInstanceDtlMap.get("id_in"));
        List<Long> id_notIn = TypeCast.getLongList(scheduleInstanceDtlMap.get("id_notIn"));
        Long id_between1 = TypeCast.getLong(scheduleInstanceDtlMap.get("id_between1"));
        Long id_between2 = TypeCast.getLong(scheduleInstanceDtlMap.get("id_between2"));
        Long id_notBetween1 = TypeCast.getLong(scheduleInstanceDtlMap.get("id_notBetween1"));
        Long id_notBetween2 = TypeCast.getLong(scheduleInstanceDtlMap.get("id_notBetween2"));

        if (id_null != null) {
            c.andIdIsNull();
        }
        if (id_notNull != null) {
            c.andIdIsNotNull();
        }
        if (id != null) {
            c.andIdEqualTo(id);
        }
        if (id_not != null) {
            c.andIdNotEqualTo(id_not);
        }
        if (id_greater != null) {
            c.andIdGreaterThan(id_greater);
        }
        if (id_greaterEqual != null) {
            c.andIdGreaterThanOrEqualTo(id_greaterEqual);
        }
        if (id_less != null) {
            c.andIdLessThan(id_less);
        }
        if (id_lessEqual != null) {
            c.andIdLessThanOrEqualTo(id_lessEqual);
        }
        if (id_in != null) {
            c.andIdIn(id_in);
        }
        if (id_notIn != null) {
            c.andIdNotIn(id_notIn);
        }
        if (id_between1 != null) {
            c.andIdBetween(id_between1, id_between2);
        }
        if (id_notBetween1 != null) {
            c.andIdNotBetween(id_notBetween1, id_notBetween2);
        }
        String instanceId_null = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_null"));
        String instanceId_notNull = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_notNull"));
        String instanceId = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId"));
        String instanceId_not = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_not"));
        String instanceId_greater = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_greater"));
        String instanceId_greaterEqual = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_greaterEqual"));
        String instanceId_less = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_less"));
        String instanceId_lessEqual = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_lessEqual"));
        String instanceId_like = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_like"));
        String instanceId_notLike = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_notLike"));
        List<String> instanceId_in = TypeCast.getStringList(scheduleInstanceDtlMap.get("instanceId_in"));
        List<String> instanceId_notIn = TypeCast.getStringList(scheduleInstanceDtlMap.get("instanceId_notIn"));
        String instanceId_between1 = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_between1"));
        String instanceId_between2 = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_between2"));
        String instanceId_notBetween1 = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_notBetween1"));
        String instanceId_notBetween2 = TypeCast.getString(scheduleInstanceDtlMap.get("instanceId_notBetween2"));

        if (instanceId_null != null) {
            c.andInstanceIdIsNull();
        }
        if (instanceId_notNull != null) {
            c.andInstanceIdIsNotNull();
        }
        if (instanceId != null) {
            c.andInstanceIdEqualTo(instanceId);
        }
        if (instanceId_not != null) {
            c.andInstanceIdNotEqualTo(instanceId_not);
        }
        if (instanceId_greater != null) {
            c.andInstanceIdGreaterThan(instanceId_greater);
        }
        if (instanceId_greaterEqual != null) {
            c.andInstanceIdGreaterThanOrEqualTo(instanceId_greaterEqual);
        }
        if (instanceId_less != null) {
            c.andInstanceIdLessThan(instanceId_less);
        }
        if (instanceId_lessEqual != null) {
            c.andInstanceIdLessThanOrEqualTo(instanceId_lessEqual);
        }
        if (instanceId_like != null) {
            c.andInstanceIdLike(instanceId_like);
        }
        if (instanceId_notLike != null) {
            c.andInstanceIdNotLike(instanceId_notLike);
        }
        if (instanceId_in != null) {
            c.andInstanceIdIn(instanceId_in);
        }
        if (instanceId_notIn != null) {
            c.andInstanceIdNotIn(instanceId_notIn);
        }
        if (instanceId_between1 != null) {
            c.andInstanceIdBetween(instanceId_between1, instanceId_between2);
        }
        if (instanceId_notBetween1 != null) {
            c.andInstanceIdNotBetween(instanceId_notBetween1, instanceId_notBetween2);
        }
        Long workId_null = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_null"));
        Long workId_notNull = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_notNull"));
        Long workId = TypeCast.getLong(scheduleInstanceDtlMap.get("workId"));
        Long workId_not = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_not"));
        Long workId_greater = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_greater"));
        Long workId_greaterEqual = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_greaterEqual"));
        Long workId_less = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_less"));
        Long workId_lessEqual = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_lessEqual"));
        List<Long> workId_in = TypeCast.getLongList(scheduleInstanceDtlMap.get("workId_in"));
        List<Long> workId_notIn = TypeCast.getLongList(scheduleInstanceDtlMap.get("workId_notIn"));
        Long workId_between1 = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_between1"));
        Long workId_between2 = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_between2"));
        Long workId_notBetween1 = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_notBetween1"));
        Long workId_notBetween2 = TypeCast.getLong(scheduleInstanceDtlMap.get("workId_notBetween2"));

        if (workId_null != null) {
            c.andWorkIdIsNull();
        }
        if (workId_notNull != null) {
            c.andWorkIdIsNotNull();
        }
        if (workId != null) {
            c.andWorkIdEqualTo(workId);
        }
        if (workId_not != null) {
            c.andWorkIdNotEqualTo(workId_not);
        }
        if (workId_greater != null) {
            c.andWorkIdGreaterThan(workId_greater);
        }
        if (workId_greaterEqual != null) {
            c.andWorkIdGreaterThanOrEqualTo(workId_greaterEqual);
        }
        if (workId_less != null) {
            c.andWorkIdLessThan(workId_less);
        }
        if (workId_lessEqual != null) {
            c.andWorkIdLessThanOrEqualTo(workId_lessEqual);
        }
        if (workId_in != null) {
            c.andWorkIdIn(workId_in);
        }
        if (workId_notIn != null) {
            c.andWorkIdNotIn(workId_notIn);
        }
        if (workId_between1 != null) {
            c.andWorkIdBetween(workId_between1, workId_between2);
        }
        if (workId_notBetween1 != null) {
            c.andWorkIdNotBetween(workId_notBetween1, workId_notBetween2);
        }
        String workName_null = TypeCast.getString(scheduleInstanceDtlMap.get("workName_null"));
        String workName_notNull = TypeCast.getString(scheduleInstanceDtlMap.get("workName_notNull"));
        String workName = TypeCast.getString(scheduleInstanceDtlMap.get("workName"));
        String workName_not = TypeCast.getString(scheduleInstanceDtlMap.get("workName_not"));
        String workName_greater = TypeCast.getString(scheduleInstanceDtlMap.get("workName_greater"));
        String workName_greaterEqual = TypeCast.getString(scheduleInstanceDtlMap.get("workName_greaterEqual"));
        String workName_less = TypeCast.getString(scheduleInstanceDtlMap.get("workName_less"));
        String workName_lessEqual = TypeCast.getString(scheduleInstanceDtlMap.get("workName_lessEqual"));
        String workName_like = TypeCast.getString(scheduleInstanceDtlMap.get("workName_like"));
        String workName_notLike = TypeCast.getString(scheduleInstanceDtlMap.get("workName_notLike"));
        List<String> workName_in = TypeCast.getStringList(scheduleInstanceDtlMap.get("workName_in"));
        List<String> workName_notIn = TypeCast.getStringList(scheduleInstanceDtlMap.get("workName_notIn"));
        String workName_between1 = TypeCast.getString(scheduleInstanceDtlMap.get("workName_between1"));
        String workName_between2 = TypeCast.getString(scheduleInstanceDtlMap.get("workName_between2"));
        String workName_notBetween1 = TypeCast.getString(scheduleInstanceDtlMap.get("workName_notBetween1"));
        String workName_notBetween2 = TypeCast.getString(scheduleInstanceDtlMap.get("workName_notBetween2"));

        if (workName_null != null) {
            c.andWorkNameIsNull();
        }
        if (workName_notNull != null) {
            c.andWorkNameIsNotNull();
        }
        if (workName != null) {
            c.andWorkNameEqualTo(workName);
        }
        if (workName_not != null) {
            c.andWorkNameNotEqualTo(workName_not);
        }
        if (workName_greater != null) {
            c.andWorkNameGreaterThan(workName_greater);
        }
        if (workName_greaterEqual != null) {
            c.andWorkNameGreaterThanOrEqualTo(workName_greaterEqual);
        }
        if (workName_less != null) {
            c.andWorkNameLessThan(workName_less);
        }
        if (workName_lessEqual != null) {
            c.andWorkNameLessThanOrEqualTo(workName_lessEqual);
        }
        if (workName_like != null) {
            c.andWorkNameLike(workName_like);
        }
        if (workName_notLike != null) {
            c.andWorkNameNotLike(workName_notLike);
        }
        if (workName_in != null) {
            c.andWorkNameIn(workName_in);
        }
        if (workName_notIn != null) {
            c.andWorkNameNotIn(workName_notIn);
        }
        if (workName_between1 != null) {
            c.andWorkNameBetween(workName_between1, workName_between2);
        }
        if (workName_notBetween1 != null) {
            c.andWorkNameNotBetween(workName_notBetween1, workName_notBetween2);
        }
        Long workItemId_null = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_null"));
        Long workItemId_notNull = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_notNull"));
        Long workItemId = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId"));
        Long workItemId_not = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_not"));
        Long workItemId_greater = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_greater"));
        Long workItemId_greaterEqual = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_greaterEqual"));
        Long workItemId_less = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_less"));
        Long workItemId_lessEqual = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_lessEqual"));
        List<Long> workItemId_in = TypeCast.getLongList(scheduleInstanceDtlMap.get("workItemId_in"));
        List<Long> workItemId_notIn = TypeCast.getLongList(scheduleInstanceDtlMap.get("workItemId_notIn"));
        Long workItemId_between1 = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_between1"));
        Long workItemId_between2 = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_between2"));
        Long workItemId_notBetween1 = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_notBetween1"));
        Long workItemId_notBetween2 = TypeCast.getLong(scheduleInstanceDtlMap.get("workItemId_notBetween2"));

        if (workItemId_null != null) {
            c.andWorkItemIdIsNull();
        }
        if (workItemId_notNull != null) {
            c.andWorkItemIdIsNotNull();
        }
        if (workItemId != null) {
            c.andWorkItemIdEqualTo(workItemId);
        }
        if (workItemId_not != null) {
            c.andWorkItemIdNotEqualTo(workItemId_not);
        }
        if (workItemId_greater != null) {
            c.andWorkItemIdGreaterThan(workItemId_greater);
        }
        if (workItemId_greaterEqual != null) {
            c.andWorkItemIdGreaterThanOrEqualTo(workItemId_greaterEqual);
        }
        if (workItemId_less != null) {
            c.andWorkItemIdLessThan(workItemId_less);
        }
        if (workItemId_lessEqual != null) {
            c.andWorkItemIdLessThanOrEqualTo(workItemId_lessEqual);
        }
        if (workItemId_in != null) {
            c.andWorkItemIdIn(workItemId_in);
        }
        if (workItemId_notIn != null) {
            c.andWorkItemIdNotIn(workItemId_notIn);
        }
        if (workItemId_between1 != null) {
            c.andWorkItemIdBetween(workItemId_between1, workItemId_between2);
        }
        if (workItemId_notBetween1 != null) {
            c.andWorkItemIdNotBetween(workItemId_notBetween1, workItemId_notBetween2);
        }
        String workItemName_null = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_null"));
        String workItemName_notNull = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_notNull"));
        String workItemName = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName"));
        String workItemName_not = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_not"));
        String workItemName_greater = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_greater"));
        String workItemName_greaterEqual = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_greaterEqual"));
        String workItemName_less = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_less"));
        String workItemName_lessEqual = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_lessEqual"));
        String workItemName_like = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_like"));
        String workItemName_notLike = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_notLike"));
        List<String> workItemName_in = TypeCast.getStringList(scheduleInstanceDtlMap.get("workItemName_in"));
        List<String> workItemName_notIn = TypeCast.getStringList(scheduleInstanceDtlMap.get("workItemName_notIn"));
        String workItemName_between1 = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_between1"));
        String workItemName_between2 = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_between2"));
        String workItemName_notBetween1 = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_notBetween1"));
        String workItemName_notBetween2 = TypeCast.getString(scheduleInstanceDtlMap.get("workItemName_notBetween2"));

        if (workItemName_null != null) {
            c.andWorkItemNameIsNull();
        }
        if (workItemName_notNull != null) {
            c.andWorkItemNameIsNotNull();
        }
        if (workItemName != null) {
            c.andWorkItemNameEqualTo(workItemName);
        }
        if (workItemName_not != null) {
            c.andWorkItemNameNotEqualTo(workItemName_not);
        }
        if (workItemName_greater != null) {
            c.andWorkItemNameGreaterThan(workItemName_greater);
        }
        if (workItemName_greaterEqual != null) {
            c.andWorkItemNameGreaterThanOrEqualTo(workItemName_greaterEqual);
        }
        if (workItemName_less != null) {
            c.andWorkItemNameLessThan(workItemName_less);
        }
        if (workItemName_lessEqual != null) {
            c.andWorkItemNameLessThanOrEqualTo(workItemName_lessEqual);
        }
        if (workItemName_like != null) {
            c.andWorkItemNameLike(workItemName_like);
        }
        if (workItemName_notLike != null) {
            c.andWorkItemNameNotLike(workItemName_notLike);
        }
        if (workItemName_in != null) {
            c.andWorkItemNameIn(workItemName_in);
        }
        if (workItemName_notIn != null) {
            c.andWorkItemNameNotIn(workItemName_notIn);
        }
        if (workItemName_between1 != null) {
            c.andWorkItemNameBetween(workItemName_between1, workItemName_between2);
        }
        if (workItemName_notBetween1 != null) {
            c.andWorkItemNameNotBetween(workItemName_notBetween1, workItemName_notBetween2);
        }
        String params_null = TypeCast.getString(scheduleInstanceDtlMap.get("params_null"));
        String params_notNull = TypeCast.getString(scheduleInstanceDtlMap.get("params_notNull"));
        String params = TypeCast.getString(scheduleInstanceDtlMap.get("params"));
        String params_not = TypeCast.getString(scheduleInstanceDtlMap.get("params_not"));
        String params_greater = TypeCast.getString(scheduleInstanceDtlMap.get("params_greater"));
        String params_greaterEqual = TypeCast.getString(scheduleInstanceDtlMap.get("params_greaterEqual"));
        String params_less = TypeCast.getString(scheduleInstanceDtlMap.get("params_less"));
        String params_lessEqual = TypeCast.getString(scheduleInstanceDtlMap.get("params_lessEqual"));
        String params_like = TypeCast.getString(scheduleInstanceDtlMap.get("params_like"));
        String params_notLike = TypeCast.getString(scheduleInstanceDtlMap.get("params_notLike"));
        List<String> params_in = TypeCast.getStringList(scheduleInstanceDtlMap.get("params_in"));
        List<String> params_notIn = TypeCast.getStringList(scheduleInstanceDtlMap.get("params_notIn"));
        String params_between1 = TypeCast.getString(scheduleInstanceDtlMap.get("params_between1"));
        String params_between2 = TypeCast.getString(scheduleInstanceDtlMap.get("params_between2"));
        String params_notBetween1 = TypeCast.getString(scheduleInstanceDtlMap.get("params_notBetween1"));
        String params_notBetween2 = TypeCast.getString(scheduleInstanceDtlMap.get("params_notBetween2"));

        if (params_null != null) {
            c.andParamsIsNull();
        }
        if (params_notNull != null) {
            c.andParamsIsNotNull();
        }
        if (params != null) {
            c.andParamsEqualTo(params);
        }
        if (params_not != null) {
            c.andParamsNotEqualTo(params_not);
        }
        if (params_greater != null) {
            c.andParamsGreaterThan(params_greater);
        }
        if (params_greaterEqual != null) {
            c.andParamsGreaterThanOrEqualTo(params_greaterEqual);
        }
        if (params_less != null) {
            c.andParamsLessThan(params_less);
        }
        if (params_lessEqual != null) {
            c.andParamsLessThanOrEqualTo(params_lessEqual);
        }
        if (params_like != null) {
            c.andParamsLike(params_like);
        }
        if (params_notLike != null) {
            c.andParamsNotLike(params_notLike);
        }
        if (params_in != null) {
            c.andParamsIn(params_in);
        }
        if (params_notIn != null) {
            c.andParamsNotIn(params_notIn);
        }
        if (params_between1 != null) {
            c.andParamsBetween(params_between1, params_between2);
        }
        if (params_notBetween1 != null) {
            c.andParamsNotBetween(params_notBetween1, params_notBetween2);
        }
        Integer runStatus_null = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_null"));
        Integer runStatus_notNull = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_notNull"));
        Integer runStatus = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus"));
        Integer runStatus_not = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_not"));
        Integer runStatus_greater = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_greater"));
        Integer runStatus_greaterEqual = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_greaterEqual"));
        Integer runStatus_less = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_less"));
        Integer runStatus_lessEqual = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_lessEqual"));
        List<Integer> runStatus_in = TypeCast.getIntegerList(scheduleInstanceDtlMap.get("runStatus_in"));
        List<Integer> runStatus_notIn = TypeCast.getIntegerList(scheduleInstanceDtlMap.get("runStatus_notIn"));
        Integer runStatus_between1 = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_between1"));
        Integer runStatus_between2 = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_between2"));
        Integer runStatus_notBetween1 = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_notBetween1"));
        Integer runStatus_notBetween2 = TypeCast.getInteger(scheduleInstanceDtlMap.get("runStatus_notBetween2"));

        if (runStatus_null != null) {
            c.andRunStatusIsNull();
        }
        if (runStatus_notNull != null) {
            c.andRunStatusIsNotNull();
        }
        if (runStatus != null) {
            c.andRunStatusEqualTo(runStatus);
        }
        if (runStatus_not != null) {
            c.andRunStatusNotEqualTo(runStatus_not);
        }
        if (runStatus_greater != null) {
            c.andRunStatusGreaterThan(runStatus_greater);
        }
        if (runStatus_greaterEqual != null) {
            c.andRunStatusGreaterThanOrEqualTo(runStatus_greaterEqual);
        }
        if (runStatus_less != null) {
            c.andRunStatusLessThan(runStatus_less);
        }
        if (runStatus_lessEqual != null) {
            c.andRunStatusLessThanOrEqualTo(runStatus_lessEqual);
        }
        if (runStatus_in != null) {
            c.andRunStatusIn(runStatus_in);
        }
        if (runStatus_notIn != null) {
            c.andRunStatusNotIn(runStatus_notIn);
        }
        if (runStatus_between1 != null) {
            c.andRunStatusBetween(runStatus_between1, runStatus_between2);
        }
        if (runStatus_notBetween1 != null) {
            c.andRunStatusNotBetween(runStatus_notBetween1, runStatus_notBetween2);
        }
        String remark_null = TypeCast.getString(scheduleInstanceDtlMap.get("remark_null"));
        String remark_notNull = TypeCast.getString(scheduleInstanceDtlMap.get("remark_notNull"));
        String remark = TypeCast.getString(scheduleInstanceDtlMap.get("remark"));
        String remark_not = TypeCast.getString(scheduleInstanceDtlMap.get("remark_not"));
        String remark_greater = TypeCast.getString(scheduleInstanceDtlMap.get("remark_greater"));
        String remark_greaterEqual = TypeCast.getString(scheduleInstanceDtlMap.get("remark_greaterEqual"));
        String remark_less = TypeCast.getString(scheduleInstanceDtlMap.get("remark_less"));
        String remark_lessEqual = TypeCast.getString(scheduleInstanceDtlMap.get("remark_lessEqual"));
        String remark_like = TypeCast.getString(scheduleInstanceDtlMap.get("remark_like"));
        String remark_notLike = TypeCast.getString(scheduleInstanceDtlMap.get("remark_notLike"));
        List<String> remark_in = TypeCast.getStringList(scheduleInstanceDtlMap.get("remark_in"));
        List<String> remark_notIn = TypeCast.getStringList(scheduleInstanceDtlMap.get("remark_notIn"));
        String remark_between1 = TypeCast.getString(scheduleInstanceDtlMap.get("remark_between1"));
        String remark_between2 = TypeCast.getString(scheduleInstanceDtlMap.get("remark_between2"));
        String remark_notBetween1 = TypeCast.getString(scheduleInstanceDtlMap.get("remark_notBetween1"));
        String remark_notBetween2 = TypeCast.getString(scheduleInstanceDtlMap.get("remark_notBetween2"));

        if (remark_null != null) {
            c.andRemarkIsNull();
        }
        if (remark_notNull != null) {
            c.andRemarkIsNotNull();
        }
        if (remark != null) {
            c.andRemarkEqualTo(remark);
        }
        if (remark_not != null) {
            c.andRemarkNotEqualTo(remark_not);
        }
        if (remark_greater != null) {
            c.andRemarkGreaterThan(remark_greater);
        }
        if (remark_greaterEqual != null) {
            c.andRemarkGreaterThanOrEqualTo(remark_greaterEqual);
        }
        if (remark_less != null) {
            c.andRemarkLessThan(remark_less);
        }
        if (remark_lessEqual != null) {
            c.andRemarkLessThanOrEqualTo(remark_lessEqual);
        }
        if (remark_like != null) {
            c.andRemarkLike(remark_like);
        }
        if (remark_notLike != null) {
            c.andRemarkNotLike(remark_notLike);
        }
        if (remark_in != null) {
            c.andRemarkIn(remark_in);
        }
        if (remark_notIn != null) {
            c.andRemarkNotIn(remark_notIn);
        }
        if (remark_between1 != null) {
            c.andRemarkBetween(remark_between1, remark_between2);
        }
        if (remark_notBetween1 != null) {
            c.andRemarkNotBetween(remark_notBetween1, remark_notBetween2);
        }
        String error_null = TypeCast.getString(scheduleInstanceDtlMap.get("error_null"));
        String error_notNull = TypeCast.getString(scheduleInstanceDtlMap.get("error_notNull"));
        String error = TypeCast.getString(scheduleInstanceDtlMap.get("error"));
        String error_not = TypeCast.getString(scheduleInstanceDtlMap.get("error_not"));
        String error_greater = TypeCast.getString(scheduleInstanceDtlMap.get("error_greater"));
        String error_greaterEqual = TypeCast.getString(scheduleInstanceDtlMap.get("error_greaterEqual"));
        String error_less = TypeCast.getString(scheduleInstanceDtlMap.get("error_less"));
        String error_lessEqual = TypeCast.getString(scheduleInstanceDtlMap.get("error_lessEqual"));
        String error_like = TypeCast.getString(scheduleInstanceDtlMap.get("error_like"));
        String error_notLike = TypeCast.getString(scheduleInstanceDtlMap.get("error_notLike"));
        List<String> error_in = TypeCast.getStringList(scheduleInstanceDtlMap.get("error_in"));
        List<String> error_notIn = TypeCast.getStringList(scheduleInstanceDtlMap.get("error_notIn"));
        String error_between1 = TypeCast.getString(scheduleInstanceDtlMap.get("error_between1"));
        String error_between2 = TypeCast.getString(scheduleInstanceDtlMap.get("error_between2"));
        String error_notBetween1 = TypeCast.getString(scheduleInstanceDtlMap.get("error_notBetween1"));
        String error_notBetween2 = TypeCast.getString(scheduleInstanceDtlMap.get("error_notBetween2"));

        if (error_null != null) {
            c.andErrorIsNull();
        }
        if (error_notNull != null) {
            c.andErrorIsNotNull();
        }
        if (error != null) {
            c.andErrorEqualTo(error);
        }
        if (error_not != null) {
            c.andErrorNotEqualTo(error_not);
        }
        if (error_greater != null) {
            c.andErrorGreaterThan(error_greater);
        }
        if (error_greaterEqual != null) {
            c.andErrorGreaterThanOrEqualTo(error_greaterEqual);
        }
        if (error_less != null) {
            c.andErrorLessThan(error_less);
        }
        if (error_lessEqual != null) {
            c.andErrorLessThanOrEqualTo(error_lessEqual);
        }
        if (error_like != null) {
            c.andErrorLike(error_like);
        }
        if (error_notLike != null) {
            c.andErrorNotLike(error_notLike);
        }
        if (error_in != null) {
            c.andErrorIn(error_in);
        }
        if (error_notIn != null) {
            c.andErrorNotIn(error_notIn);
        }
        if (error_between1 != null) {
            c.andErrorBetween(error_between1, error_between2);
        }
        if (error_notBetween1 != null) {
            c.andErrorNotBetween(error_notBetween1, error_notBetween2);
        }
        String execIp_null = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_null"));
        String execIp_notNull = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_notNull"));
        String execIp = TypeCast.getString(scheduleInstanceDtlMap.get("execIp"));
        String execIp_not = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_not"));
        String execIp_greater = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_greater"));
        String execIp_greaterEqual = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_greaterEqual"));
        String execIp_less = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_less"));
        String execIp_lessEqual = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_lessEqual"));
        String execIp_like = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_like"));
        String execIp_notLike = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_notLike"));
        List<String> execIp_in = TypeCast.getStringList(scheduleInstanceDtlMap.get("execIp_in"));
        List<String> execIp_notIn = TypeCast.getStringList(scheduleInstanceDtlMap.get("execIp_notIn"));
        String execIp_between1 = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_between1"));
        String execIp_between2 = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_between2"));
        String execIp_notBetween1 = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_notBetween1"));
        String execIp_notBetween2 = TypeCast.getString(scheduleInstanceDtlMap.get("execIp_notBetween2"));

        if (execIp_null != null) {
            c.andExecIpIsNull();
        }
        if (execIp_notNull != null) {
            c.andExecIpIsNotNull();
        }
        if (execIp != null) {
            c.andExecIpEqualTo(execIp);
        }
        if (execIp_not != null) {
            c.andExecIpNotEqualTo(execIp_not);
        }
        if (execIp_greater != null) {
            c.andExecIpGreaterThan(execIp_greater);
        }
        if (execIp_greaterEqual != null) {
            c.andExecIpGreaterThanOrEqualTo(execIp_greaterEqual);
        }
        if (execIp_less != null) {
            c.andExecIpLessThan(execIp_less);
        }
        if (execIp_lessEqual != null) {
            c.andExecIpLessThanOrEqualTo(execIp_lessEqual);
        }
        if (execIp_like != null) {
            c.andExecIpLike(execIp_like);
        }
        if (execIp_notLike != null) {
            c.andExecIpNotLike(execIp_notLike);
        }
        if (execIp_in != null) {
            c.andExecIpIn(execIp_in);
        }
        if (execIp_notIn != null) {
            c.andExecIpNotIn(execIp_notIn);
        }
        if (execIp_between1 != null) {
            c.andExecIpBetween(execIp_between1, execIp_between2);
        }
        if (execIp_notBetween1 != null) {
            c.andExecIpNotBetween(execIp_notBetween1, execIp_notBetween2);
        }
        Integer totalNum_null = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_null"));
        Integer totalNum_notNull = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_notNull"));
        Integer totalNum = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum"));
        Integer totalNum_not = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_not"));
        Integer totalNum_greater = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_greater"));
        Integer totalNum_greaterEqual = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_greaterEqual"));
        Integer totalNum_less = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_less"));
        Integer totalNum_lessEqual = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_lessEqual"));
        List<Integer> totalNum_in = TypeCast.getIntegerList(scheduleInstanceDtlMap.get("totalNum_in"));
        List<Integer> totalNum_notIn = TypeCast.getIntegerList(scheduleInstanceDtlMap.get("totalNum_notIn"));
        Integer totalNum_between1 = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_between1"));
        Integer totalNum_between2 = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_between2"));
        Integer totalNum_notBetween1 = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_notBetween1"));
        Integer totalNum_notBetween2 = TypeCast.getInteger(scheduleInstanceDtlMap.get("totalNum_notBetween2"));

        if (totalNum_null != null) {
            c.andTotalNumIsNull();
        }
        if (totalNum_notNull != null) {
            c.andTotalNumIsNotNull();
        }
        if (totalNum != null) {
            c.andTotalNumEqualTo(totalNum);
        }
        if (totalNum_not != null) {
            c.andTotalNumNotEqualTo(totalNum_not);
        }
        if (totalNum_greater != null) {
            c.andTotalNumGreaterThan(totalNum_greater);
        }
        if (totalNum_greaterEqual != null) {
            c.andTotalNumGreaterThanOrEqualTo(totalNum_greaterEqual);
        }
        if (totalNum_less != null) {
            c.andTotalNumLessThan(totalNum_less);
        }
        if (totalNum_lessEqual != null) {
            c.andTotalNumLessThanOrEqualTo(totalNum_lessEqual);
        }
        if (totalNum_in != null) {
            c.andTotalNumIn(totalNum_in);
        }
        if (totalNum_notIn != null) {
            c.andTotalNumNotIn(totalNum_notIn);
        }
        if (totalNum_between1 != null) {
            c.andTotalNumBetween(totalNum_between1, totalNum_between2);
        }
        if (totalNum_notBetween1 != null) {
            c.andTotalNumNotBetween(totalNum_notBetween1, totalNum_notBetween2);
        }
        Integer succNum_null = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_null"));
        Integer succNum_notNull = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_notNull"));
        Integer succNum = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum"));
        Integer succNum_not = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_not"));
        Integer succNum_greater = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_greater"));
        Integer succNum_greaterEqual = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_greaterEqual"));
        Integer succNum_less = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_less"));
        Integer succNum_lessEqual = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_lessEqual"));
        List<Integer> succNum_in = TypeCast.getIntegerList(scheduleInstanceDtlMap.get("succNum_in"));
        List<Integer> succNum_notIn = TypeCast.getIntegerList(scheduleInstanceDtlMap.get("succNum_notIn"));
        Integer succNum_between1 = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_between1"));
        Integer succNum_between2 = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_between2"));
        Integer succNum_notBetween1 = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_notBetween1"));
        Integer succNum_notBetween2 = TypeCast.getInteger(scheduleInstanceDtlMap.get("succNum_notBetween2"));

        if (succNum_null != null) {
            c.andSuccNumIsNull();
        }
        if (succNum_notNull != null) {
            c.andSuccNumIsNotNull();
        }
        if (succNum != null) {
            c.andSuccNumEqualTo(succNum);
        }
        if (succNum_not != null) {
            c.andSuccNumNotEqualTo(succNum_not);
        }
        if (succNum_greater != null) {
            c.andSuccNumGreaterThan(succNum_greater);
        }
        if (succNum_greaterEqual != null) {
            c.andSuccNumGreaterThanOrEqualTo(succNum_greaterEqual);
        }
        if (succNum_less != null) {
            c.andSuccNumLessThan(succNum_less);
        }
        if (succNum_lessEqual != null) {
            c.andSuccNumLessThanOrEqualTo(succNum_lessEqual);
        }
        if (succNum_in != null) {
            c.andSuccNumIn(succNum_in);
        }
        if (succNum_notIn != null) {
            c.andSuccNumNotIn(succNum_notIn);
        }
        if (succNum_between1 != null) {
            c.andSuccNumBetween(succNum_between1, succNum_between2);
        }
        if (succNum_notBetween1 != null) {
            c.andSuccNumNotBetween(succNum_notBetween1, succNum_notBetween2);
        }
        Integer errNum_null = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_null"));
        Integer errNum_notNull = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_notNull"));
        Integer errNum = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum"));
        Integer errNum_not = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_not"));
        Integer errNum_greater = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_greater"));
        Integer errNum_greaterEqual = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_greaterEqual"));
        Integer errNum_less = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_less"));
        Integer errNum_lessEqual = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_lessEqual"));
        List<Integer> errNum_in = TypeCast.getIntegerList(scheduleInstanceDtlMap.get("errNum_in"));
        List<Integer> errNum_notIn = TypeCast.getIntegerList(scheduleInstanceDtlMap.get("errNum_notIn"));
        Integer errNum_between1 = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_between1"));
        Integer errNum_between2 = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_between2"));
        Integer errNum_notBetween1 = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_notBetween1"));
        Integer errNum_notBetween2 = TypeCast.getInteger(scheduleInstanceDtlMap.get("errNum_notBetween2"));

        if (errNum_null != null) {
            c.andErrNumIsNull();
        }
        if (errNum_notNull != null) {
            c.andErrNumIsNotNull();
        }
        if (errNum != null) {
            c.andErrNumEqualTo(errNum);
        }
        if (errNum_not != null) {
            c.andErrNumNotEqualTo(errNum_not);
        }
        if (errNum_greater != null) {
            c.andErrNumGreaterThan(errNum_greater);
        }
        if (errNum_greaterEqual != null) {
            c.andErrNumGreaterThanOrEqualTo(errNum_greaterEqual);
        }
        if (errNum_less != null) {
            c.andErrNumLessThan(errNum_less);
        }
        if (errNum_lessEqual != null) {
            c.andErrNumLessThanOrEqualTo(errNum_lessEqual);
        }
        if (errNum_in != null) {
            c.andErrNumIn(errNum_in);
        }
        if (errNum_notIn != null) {
            c.andErrNumNotIn(errNum_notIn);
        }
        if (errNum_between1 != null) {
            c.andErrNumBetween(errNum_between1, errNum_between2);
        }
        if (errNum_notBetween1 != null) {
            c.andErrNumNotBetween(errNum_notBetween1, errNum_notBetween2);
        }
        Date createTime_null = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_null"));
        Date createTime_notNull = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_notNull"));
        Date createTime = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime"));
        Date createTime_not = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_not"));
        Date createTime_greater = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_greater"));
        Date createTime_greaterEqual = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_greaterEqual"));
        Date createTime_less = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_less"));
        Date createTime_lessEqual = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_lessEqual"));
        List<Date> createTime_in = TypeCast.getDateList(scheduleInstanceDtlMap.get("createTime_in"));
        List<Date> createTime_notIn = TypeCast.getDateList(scheduleInstanceDtlMap.get("createTime_notIn"));
        Date createTime_between1 = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_between1"));
        Date createTime_between2 = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_between2"));
        Date createTime_notBetween1 = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_notBetween1"));
        Date createTime_notBetween2 = TypeCast.getDate(scheduleInstanceDtlMap.get("createTime_notBetween2"));

        if (createTime_null != null) {
            c.andCreateTimeIsNull();
        }
        if (createTime_notNull != null) {
            c.andCreateTimeIsNotNull();
        }
        if (createTime != null) {
            c.andCreateTimeEqualTo(createTime);
        }
        if (createTime_not != null) {
            c.andCreateTimeNotEqualTo(createTime_not);
        }
        if (createTime_greater != null) {
            c.andCreateTimeGreaterThan(createTime_greater);
        }
        if (createTime_greaterEqual != null) {
            c.andCreateTimeGreaterThanOrEqualTo(createTime_greaterEqual);
        }
        if (createTime_less != null) {
            c.andCreateTimeLessThan(createTime_less);
        }
        if (createTime_lessEqual != null) {
            c.andCreateTimeLessThanOrEqualTo(createTime_lessEqual);
        }
        if (createTime_in != null) {
            c.andCreateTimeIn(createTime_in);
        }
        if (createTime_notIn != null) {
            c.andCreateTimeNotIn(createTime_notIn);
        }
        if (createTime_between1 != null) {
            c.andCreateTimeBetween(createTime_between1, createTime_between2);
        }
        if (createTime_notBetween1 != null) {
            c.andCreateTimeNotBetween(createTime_notBetween1, createTime_notBetween2);
        }
        Date updateTime_null = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_null"));
        Date updateTime_notNull = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_notNull"));
        Date updateTime = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime"));
        Date updateTime_not = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_not"));
        Date updateTime_greater = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_greater"));
        Date updateTime_greaterEqual = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_greaterEqual"));
        Date updateTime_less = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_less"));
        Date updateTime_lessEqual = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_lessEqual"));
        List<Date> updateTime_in = TypeCast.getDateList(scheduleInstanceDtlMap.get("updateTime_in"));
        List<Date> updateTime_notIn = TypeCast.getDateList(scheduleInstanceDtlMap.get("updateTime_notIn"));
        Date updateTime_between1 = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_between1"));
        Date updateTime_between2 = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_between2"));
        Date updateTime_notBetween1 = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_notBetween1"));
        Date updateTime_notBetween2 = TypeCast.getDate(scheduleInstanceDtlMap.get("updateTime_notBetween2"));

        if (updateTime_null != null) {
            c.andUpdateTimeIsNull();
        }
        if (updateTime_notNull != null) {
            c.andUpdateTimeIsNotNull();
        }
        if (updateTime != null) {
            c.andUpdateTimeEqualTo(updateTime);
        }
        if (updateTime_not != null) {
            c.andUpdateTimeNotEqualTo(updateTime_not);
        }
        if (updateTime_greater != null) {
            c.andUpdateTimeGreaterThan(updateTime_greater);
        }
        if (updateTime_greaterEqual != null) {
            c.andUpdateTimeGreaterThanOrEqualTo(updateTime_greaterEqual);
        }
        if (updateTime_less != null) {
            c.andUpdateTimeLessThan(updateTime_less);
        }
        if (updateTime_lessEqual != null) {
            c.andUpdateTimeLessThanOrEqualTo(updateTime_lessEqual);
        }
        if (updateTime_in != null) {
            c.andUpdateTimeIn(updateTime_in);
        }
        if (updateTime_notIn != null) {
            c.andUpdateTimeNotIn(updateTime_notIn);
        }
        if (updateTime_between1 != null) {
            c.andUpdateTimeBetween(updateTime_between1, updateTime_between2);
        }
        if (updateTime_notBetween1 != null) {
            c.andUpdateTimeNotBetween(updateTime_notBetween1, updateTime_notBetween2);
        }
        if (scheduleInstanceDtlMap.get("orderBy") != null) {
            scheduleInstanceDtlEx.setOrderByClause((String) scheduleInstanceDtlMap.get("orderBy"));
        }
        if (limitStart != null && limitOffset != null) {
            scheduleInstanceDtlEx.setLimitStart(limitStart);
            scheduleInstanceDtlEx.setLimitOffset(limitOffset);
        }

        return scheduleInstanceDtlEx;
    }
}
